home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Applications / Python 1.4 / Python 1.4 source / Mac / Lib / FrameWork.py < prev    next >
Encoding:
Python Source  |  1996-09-30  |  25.0 KB  |  946 lines  |  [TEXT/Pyth]
  1. "A sort of application framework for the Mac"
  2.  
  3. DEBUG=0
  4.  
  5. import MacOS
  6. import traceback
  7.  
  8. from AE import *
  9. from AppleEvents import *
  10. from Ctl import *
  11. from Controls import *
  12. from Dlg import *
  13. from Dialogs import *
  14. from Evt import *
  15. from Events import *
  16. from Menu import *
  17. from Menus import *
  18. from Qd import *
  19. from QuickDraw import *
  20. #from Res import *
  21. #from Resources import *
  22. #from Snd import *
  23. #from Sound import *
  24. from Win import *
  25. from Windows import *
  26. import types
  27.  
  28. import EasyDialogs
  29.  
  30. kHighLevelEvent = 23    # Don't know what header file this should come from
  31. SCROLLBARWIDTH = 16        # Again, not a clue...
  32.  
  33.  
  34. # Map event 'what' field to strings
  35. eventname = {}
  36. eventname[1] = 'mouseDown'
  37. eventname[2] = 'mouseUp'
  38. eventname[3] = 'keyDown'
  39. eventname[4] = 'keyUp'
  40. eventname[5] = 'autoKey'
  41. eventname[6] = 'updateEvt'
  42. eventname[7] = 'diskEvt'
  43. eventname[8] = 'activateEvt'
  44. eventname[15] = 'osEvt'
  45. eventname[23] = 'kHighLevelEvent'
  46.  
  47. # Map part codes returned by WhichWindow() to strings
  48. partname = {}
  49. partname[0] = 'inDesk'
  50. partname[1] = 'inMenuBar'
  51. partname[2] = 'inSysWindow'
  52. partname[3] = 'inContent'
  53. partname[4] = 'inDrag'
  54. partname[5] = 'inGrow'
  55. partname[6] = 'inGoAway'
  56. partname[7] = 'inZoomIn'
  57. partname[8] = 'inZoomOut'
  58.  
  59. #
  60. # The useable portion of the screen
  61. #    ## but what happens with multiple screens? jvr
  62. screenbounds = qd.screenBits.bounds
  63. screenbounds = screenbounds[0]+4, screenbounds[1]+4, \
  64.     screenbounds[2]-4, screenbounds[3]-4
  65.     
  66. next_window_x = 16        # jvr
  67. next_window_y = 44        # jvr
  68.  
  69. def windowbounds(width, height):
  70.     "Return sensible window bounds"
  71.     global next_window_x, next_window_y
  72.     r, b = next_window_x+width, next_window_y+height
  73.     if r > screenbounds[2]:
  74.         next_window_x = 16
  75.     if b > screenbounds[3]:
  76.         next_window_y = 44
  77.     l, t = next_window_x, next_window_y
  78.     r, b = next_window_x+width, next_window_y+height
  79.     next_window_x, next_window_y = next_window_x + 8, next_window_y + 20    # jvr
  80.     return l, t, r, b
  81.  
  82. _watch = None
  83. def setwatchcursor():
  84.     global _watch
  85.     
  86.     if _watch == None:
  87.         _watch = GetCursor(4).data
  88.     SetCursor(_watch)
  89.     
  90. def setarrowcursor():
  91.     SetCursor(qd.arrow)
  92.  
  93. class Application:
  94.     
  95.     "Application framework -- your application should be a derived class"
  96.     
  97.     def __init__(self, nomenubar=0):
  98.         self.quitting = 0
  99.         self.needmenubarredraw = 0
  100.         self._windows = {}
  101.         if nomenubar:
  102.             self.menubar = None
  103.         else:
  104.             self.makemenubar()
  105.     
  106.     def makemenubar(self):
  107.         self.menubar = MenuBar(self)
  108.         AppleMenu(self.menubar, self.getabouttext(), self.do_about)
  109.         self.makeusermenus()
  110.  
  111.     def makeusermenus(self):
  112.         self.filemenu = m = Menu(self.menubar, "File")
  113.         self._quititem = MenuItem(m, "Quit", "Q", self._quit)
  114.     
  115.     def _quit(self, *args):
  116.         self.quitting = 1
  117.         
  118.     def appendwindow(self, wid, window):
  119.         self._windows[wid] = window
  120.         
  121.     def removewindow(self, wid):
  122.         del self._windows[wid]
  123.     
  124.     def getabouttext(self):
  125.         return "About %s..." % self.__class__.__name__
  126.     
  127.     def do_about(self, id, item, window, event):
  128.         EasyDialogs.Message("Hello, world!" + "\015(%s)" % self.__class__.__name__)
  129.     
  130.     # The main event loop is broken up in several simple steps.
  131.     # This is done so you can override each individual part,
  132.     # if you have a need to do extra processing independent of the
  133.     # event type.
  134.     # Normally, however, you'd just define handlers for individual
  135.     # events.
  136.     # (XXX I'm not sure if using default parameter values is the right
  137.     # way to define the mask and wait time passed to WaitNextEvent.)
  138.     
  139.     def mainloop(self, mask = everyEvent, wait = 0):
  140.         self.quitting = 0
  141.         saveyield = MacOS.EnableAppswitch(self.yield)
  142.         try:
  143.             while not self.quitting:
  144.                 try:
  145.                     self.do1event(mask, wait)
  146.                 except (Application, SystemExit):
  147.                     # Note: the raising of "self" is old-fashioned idiom to
  148.                     # exit the mainloop. Calling _quit() is better for new
  149.                     # applications.
  150.                     break
  151.         finally:
  152.             MacOS.EnableAppswitch(saveyield)
  153.     
  154.     yield = -1
  155.     
  156.     def do1event(self, mask = everyEvent, wait = 0):
  157.         ok, event = self.getevent(mask, wait)
  158.         if IsDialogEvent(event):
  159.             if self.do_dialogevent(event):
  160.                 return
  161.         if ok:
  162.             self.dispatch(event)
  163.         else:
  164.             self.idle(event)
  165.             
  166.     def idle(self, event):
  167.         pass
  168.     
  169.     def getevent(self, mask = everyEvent, wait = 0):
  170.         if self.needmenubarredraw:
  171.             DrawMenuBar()
  172.             self.needmenubarredraw = 0
  173.         ok, event = WaitNextEvent(mask, wait)
  174.         return ok, event
  175.             
  176.     def dispatch(self, event):
  177.         (what, message, when, where, modifiers) = event
  178.         if eventname.has_key(what):
  179.             name = "do_" + eventname[what]
  180.         else:
  181.             name = "do_%d" % what
  182.         try:
  183.             handler = getattr(self, name)
  184.         except AttributeError:
  185.             handler = self.do_unknownevent
  186.         handler(event)
  187.         
  188.     def do_dialogevent(self, event):
  189.         gotone, window, item = DialogSelect(event)
  190.         if gotone:
  191.             if self._windows.has_key(window):
  192.                 self._windows[window].do_itemhit(item, event)
  193.             else:
  194.                 print 'Dialog event for unknown dialog'
  195.             return 1
  196.         return 0
  197.     
  198.     def do_mouseDown(self, event):
  199.         (what, message, when, where, modifiers) = event
  200.         partcode, wid = FindWindow(where)
  201.  
  202.         #
  203.         # Find the correct name.
  204.         #
  205.         if partname.has_key(partcode):
  206.             name = "do_" + partname[partcode]
  207.         else:
  208.             name = "do_%d" % partcode
  209.  
  210.         if wid == None:
  211.             # No window, or a non-python window    
  212.             try:
  213.                 handler = getattr(self, name)
  214.             except AttributeError:
  215.                 # Not menubar or something, so assume someone
  216.                 # else's window
  217.                 MacOS.HandleEvent(event)
  218.                 return        
  219.         elif self._windows.has_key(wid):
  220.             # It is a window. Hand off to correct window.
  221.             window = self._windows[wid]
  222.             try:
  223.                 handler = getattr(window, name)
  224.             except AttributeError:
  225.                 handler = self.do_unknownpartcode
  226.         else:
  227.             # It is a python-toolbox window, but not ours.
  228.             handler = self.do_unknownwindow
  229.         handler(partcode, wid, event)
  230.  
  231.     def do_inSysWindow(self, partcode, window, event):
  232.         MacOS.HandleEvent(event)
  233.     
  234.     def do_inDesk(self, partcode, window, event):
  235.         MacOS.HandleEvent(event)
  236.     
  237.     def do_inMenuBar(self, partcode, window, event):
  238.         if not self.menubar:
  239.             MacOS.HandleEvent(event)
  240.             return
  241.         (what, message, when, where, modifiers) = event
  242.         result = MenuSelect(where)
  243.         id = (result>>16) & 0xffff    # Hi word
  244.         item = result & 0xffff        # Lo word
  245.         self.do_rawmenu(id, item, window, event)
  246.     
  247.     def do_rawmenu(self, id, item, window, event):
  248.         try:
  249.             self.do_menu(id, item, window, event)
  250.         finally:
  251.             HiliteMenu(0)
  252.     
  253.     def do_menu(self, id, item, window, event):
  254.         self.menubar.dispatch(id, item, window, event)
  255.     
  256.     
  257.     def do_unknownpartcode(self, partcode, window, event):
  258.         (what, message, when, where, modifiers) = event
  259.         if DEBUG: print "Mouse down at global:", where
  260.         if DEBUG: print "\tUnknown part code:", partcode
  261.         if DEBUG: print "\tEvent:", self.printevent(event)
  262.         MacOS.HandleEvent(event)
  263.         
  264.     def do_unknownwindow(self, partcode, window, event):
  265.         if DEBUG: print 'Unknown window:', window
  266.         MacOS.HandleEvent(event)
  267.     
  268.     def do_keyDown(self, event):
  269.         self.do_key(event)
  270.     
  271.     def do_autoKey(self, event):
  272.         if not event[-1] & cmdKey:
  273.             self.do_key(event)
  274.     
  275.     def do_key(self, event):
  276.         (what, message, when, where, modifiers) = event
  277.         c = chr(message & charCodeMask)
  278.         if modifiers & cmdKey:
  279.             if c == '.':
  280.                 raise self
  281.             else:
  282.                 if not self.menubar:
  283.                     MacOS.HandleEvent(event)
  284.                     return
  285.                 result = MenuKey(ord(c))
  286.                 id = (result>>16) & 0xffff    # Hi word
  287.                 item = result & 0xffff        # Lo word
  288.                 if id:
  289.                     self.do_rawmenu(id, item, None, event)
  290. #                elif c == 'w':
  291. #                    w = FrontWindow()
  292. #                    if w:
  293. #                        self.do_close(w)
  294. #                    else:
  295. #                        if DEBUG: print 'Command-W without front window'
  296.                 else:
  297.                     if DEBUG: print "Command-" +`c`
  298.         else:
  299.             # See whether the front window wants it
  300.             w = FrontWindow()
  301.             if w and self._windows.has_key(w):
  302.                 window = self._windows[w]
  303.                 try:
  304.                     do_char = window.do_char
  305.                 except AttributeError:
  306.                     do_char = self.do_char
  307.                 do_char(c, event)
  308.             # else it wasn't for us, sigh...
  309.     
  310.     def do_char(self, c, event):
  311.         if DEBUG: print "Character", `c`
  312.     
  313.     def do_updateEvt(self, event):
  314.         (what, message, when, where, modifiers) = event
  315.         wid = WhichWindow(message)
  316.         if wid and self._windows.has_key(wid):
  317.             window = self._windows[wid]
  318.             window.do_rawupdate(wid, event)
  319.         else:
  320.             MacOS.HandleEvent(event)
  321.     
  322.     def do_activateEvt(self, event):
  323.         (what, message, when, where, modifiers) = event
  324.         # XXXX Incorrect, should be fixed in suspendresume
  325.         if type(message) == type(1):
  326.             wid = WhichWindow(message)
  327.         else:
  328.             wid = message
  329.         if wid and self._windows.has_key(wid):
  330.             window = self._windows[wid]
  331.             window.do_activate(modifiers & 1, event)
  332.         else:
  333.             MacOS.HandleEvent(event)
  334.             
  335.     def do_osEvt(self, event):
  336.         (what, message, when, where, modifiers) = event
  337.         which = (message >> 24) & 0xff
  338.         if which == 1:    # suspend/resume
  339.             self.do_suspendresume(event)
  340.         else:
  341.             if DEBUG:
  342.                 print 'unknown osEvt:',
  343.                 self.printevent(event)
  344.                 
  345.     def do_suspendresume(self, event):
  346.         # Is this a good idea???
  347.         (what, message, when, where, modifiers) = event
  348.         w = FrontWindow()
  349.         if w:
  350.             # XXXX Incorrect, should stuff windowptr into message field
  351.             nev = (activateEvt, w, when, where, message&1)
  352.             self.do_activateEvt(nev)
  353.  
  354.     def do_kHighLevelEvent(self, event):
  355.         (what, message, when, where, modifiers) = event
  356.         if DEBUG: 
  357.             print "High Level Event:",
  358.             self.printevent(event)
  359.         try:
  360.             AEProcessAppleEvent(event)
  361.         except:
  362.             print "AEProcessAppleEvent error:"
  363.             traceback.print_exc()
  364.     
  365.     def do_unknownevent(self, event):
  366.         if DEBUG:
  367.             print "Unhandled event:",
  368.             self.printevent(event)
  369.     
  370.     def printevent(self, event):
  371.         (what, message, when, where, modifiers) = event
  372.         nicewhat = `what`
  373.         if eventname.has_key(what):
  374.             nicewhat = eventname[what]
  375.         print nicewhat,
  376.         if what == kHighLevelEvent:
  377.             h, v = where
  378.             print `ostypecode(message)`, hex(when), `ostypecode(h | (v<<16))`,
  379.         else:
  380.             print hex(message), hex(when), where,
  381.         print hex(modifiers)
  382.  
  383.  
  384. class MenuBar:
  385.     """Represent a set of menus in a menu bar.
  386.     
  387.     Interface:
  388.     
  389.     - (constructor)
  390.     - (destructor)
  391.     - addmenu
  392.     - addpopup (normally used internally)
  393.     - dispatch (called from Application)
  394.     """
  395.     
  396.     nextid = 1    # Necessarily a class variable
  397.     
  398.     def getnextid(self):
  399.         id = MenuBar.nextid
  400.         MenuBar.nextid = id+1
  401.         return id
  402.     
  403.     def __init__(self, parent=None):
  404.         self.parent = parent
  405.         ClearMenuBar()
  406.         self.bar = GetMenuBar()
  407.         self.menus = {}
  408.     
  409.     # XXX necessary?
  410.     def close(self):
  411.         self.parent = None
  412.         self.bar = None
  413.     
  414.     def addmenu(self, title, after = 0):
  415.         id = self.getnextid()
  416.         if DEBUG: print 'Newmenu', title, id # XXXX
  417.         m = NewMenu(id, title)
  418.         m.InsertMenu(after)
  419.         if self.parent:
  420.             self.parent.needmenubarredraw = 1
  421.         else:
  422.             DrawMenuBar()
  423.         return id, m
  424.         
  425.     def delmenu(self, id):
  426.         if DEBUG: print 'Delmenu', id # XXXX
  427.         DeleteMenu(id)
  428.     
  429.     def addpopup(self, title = ''):
  430.         return self.addmenu(title, -1)
  431.  
  432. # Useless:    
  433. #    def install(self):
  434. #        if not self.bar: return
  435. #        SetMenuBar(self.bar)
  436. #        if self.parent:
  437. #            self.parent.needmenubarredraw = 1
  438. #        else:
  439. #            DrawMenuBar()
  440.     
  441.     def fixmenudimstate(self):
  442.         for m in self.menus.keys():
  443.             menu = self.menus[m]
  444.             if menu.__class__ == FrameWork.AppleMenu:
  445.                 continue
  446.             for i in range(len(menu.items)):
  447.                 label, shortcut, callback, kind = menu.items[i]
  448.                 if type(callback) == types.StringType:
  449.                     wid = Win.FrontWindow()
  450.                     if wid and self.parent._windows.has_key(wid):
  451.                         window = self.parent._windows[wid]
  452.                         if hasattr(window, "domenu_" + callback):
  453.                             menu.menu.EnableItem(i + 1)
  454.                         elif hasattr(self.parent, "domenu_" + callback):
  455.                             menu.menu.EnableItem(i + 1)
  456.                         else:
  457.                             menu.menu.DisableItem(i + 1)
  458.                     elif hasattr(self.parent, "domenu_" + callback):
  459.                         menu.menu.EnableItem(i + 1)
  460.                     else:
  461.                         menu.menu.DisableItem(i + 1)
  462.                 elif callback:
  463.                     pass
  464.                     
  465.     def dispatch(self, id, item, window, event):
  466.         if self.menus.has_key(id):
  467.             self.menus[id].dispatch(id, item, window, event)
  468.         else:
  469.             if DEBUG: print "MenuBar.dispatch(%d, %d, %s, %s)" % \
  470.                 (id, item, window, event)
  471.     
  472.  
  473. # XXX Need a way to get menus as resources and bind them to callbacks
  474.  
  475. class Menu:
  476.     "One menu."
  477.     
  478.     def __init__(self, bar, title, after=0):
  479.         self.bar = bar
  480.         self.id, self.menu = self.bar.addmenu(title, after)
  481.         bar.menus[self.id] = self
  482.         self.items = []
  483.         
  484.     def delete(self):
  485.         self.bar.delmenu(self.id)
  486.         del self.bar.menus[self.id]
  487.         del self.bar
  488.         del self.items
  489.         del self.menu
  490.         del self.id
  491.     
  492.     def additem(self, label, shortcut=None, callback=None, kind=None):
  493.         self.menu.AppendMenu('x')        # add a dummy string
  494.         self.items.append(label, shortcut, callback, kind)
  495.         item = len(self.items)
  496.         self.menu.SetMenuItemText(item, label)        # set the actual text
  497.         if shortcut:
  498.             self.menu.SetItemCmd(item, ord(shortcut))
  499.         return item
  500.     
  501.     def addcheck(self, label, shortcut=None, callback=None):
  502.         return self.additem(label, shortcut, callback, 'check')
  503.     
  504.     def addradio(self, label, shortcut=None, callback=None):
  505.         return self.additem(label, shortcut, callback, 'radio')
  506.     
  507.     def addseparator(self):
  508.         self.menu.AppendMenu('(-')
  509.         self.items.append('', None, None, 'separator')
  510.     
  511.     def addsubmenu(self, label, title=''):
  512.         sub = Menu(self.bar, title, -1)
  513.         item = self.additem(label, '\x1B', None, 'submenu')
  514.         self.menu.SetItemMark(item, sub.id)
  515.         return sub
  516.     
  517.     def dispatch(self, id, item, window, event):
  518.         title, shortcut, callback, mtype = self.items[item-1]
  519.         if callback:
  520.             if not self.bar.parent or type(callback) <> types.StringType:
  521.                 menuhandler = callback
  522.             else: 
  523.                 # callback is string
  524.                 wid = Win.FrontWindow()
  525.                 if wid and self.bar.parent._windows.has_key(wid):
  526.                     window = self.bar.parent._windows[wid]
  527.                     if hasattr(window, "domenu_" + callback):
  528.                         menuhandler = getattr(window, "domenu_" + callback)
  529.                     elif hasattr(self.bar.parent, "domenu_" + callback):
  530.                         menuhandler = getattr(self.bar.parent, "domenu_" + callback)
  531.                     else:
  532.                         # nothing we can do. we shouldn't have come this far
  533.                         # since the menu item should have been disabled...
  534.                         return
  535.                 elif hasattr(self.bar.parent, "domenu_" + callback):
  536.                     menuhandler = getattr(self.bar.parent, "domenu_" + callback)
  537.                 else:
  538.                     # nothing we can do. we shouldn't have come this far
  539.                     # since the menu item should have been disabled...
  540.                     return
  541.             menuhandler(id, item, window, event)
  542.  
  543.     def enable(self, onoff):
  544.         if onoff:
  545.             self.menu.EnableItem(0)
  546.         else:
  547.             self.menu.DisableItem(0)
  548.  
  549. class MenuItem:
  550.     def __init__(self, menu, title, shortcut=None, callback=None, kind=None):
  551.         self.item = menu.additem(title, shortcut, callback)
  552.         self.menu = menu
  553.         
  554.     def check(self, onoff):
  555.         self.menu.menu.CheckItem(self.item, onoff)
  556.  
  557.     def enable(self, onoff):
  558.         if onoff:
  559.             self.menu.menu.EnableItem(self.item)
  560.         else:
  561.             self.menu.menu.DisableItem(self.item)
  562.             
  563.     def settext(self, text):
  564.         self.menu.menu.SetMenuItemText(self.item, text)
  565.         
  566.     def setstyle(self, style):
  567.         self.menu.menu.SetItemStyle(self.item, style)
  568.         
  569.     def seticon(self, icon):
  570.         self.menu.menu.SetItemIcon(self.item, icon)
  571.         
  572.     def setcmd(self, cmd):
  573.         self.menu.menu.SetItemCmd(self.item, cmd)
  574.         
  575.     def setmark(self, cmd):
  576.         self.menu.menu.SetItemMark(self.item, cmd)
  577.         
  578.  
  579. class RadioItem(MenuItem):
  580.     def __init__(self, menu, title, shortcut=None, callback=None):
  581.         MenuItem.__init__(self, menu, title, shortcut, callback, 'radio')
  582.  
  583. class CheckItem(MenuItem):
  584.     def __init__(self, menu, title, shortcut=None, callback=None):
  585.         MenuItem.__init__(self, menu, title, shortcut, callback, 'check')
  586.  
  587. def Separator(menu):
  588.     menu.addseparator()
  589.  
  590. def SubMenu(menu, label, title=''):
  591.     return menu.addsubmenu(label, title)
  592.  
  593.  
  594. class AppleMenu(Menu):
  595.     
  596.     def __init__(self, bar, abouttext="About me...", aboutcallback=None):
  597.         Menu.__init__(self, bar, "\024")
  598.         self.additem(abouttext, None, aboutcallback)
  599.         self.addseparator()
  600.         self.menu.AppendResMenu('DRVR')
  601.     
  602.     def dispatch(self, id, item, window, event):
  603.         if item == 1:
  604.             Menu.dispatch(self, id, item, window, event)
  605.         else:
  606.             name = self.menu.GetMenuItemText(item)
  607.             OpenDeskAcc(name)
  608.  
  609. class Window:
  610.     """A single window belonging to an application"""
  611.     
  612.     def __init__(self, parent):
  613.         self.wid = None
  614.         self.parent = parent
  615.         
  616.     def open(self, bounds=(40, 40, 400, 400), resid=None):
  617.         if resid <> None:
  618.             self.wid = GetNewWindow(resid, -1)
  619.         else:
  620.             self.wid = NewWindow(bounds, self.__class__.__name__, 1,
  621.                 8, -1, 1, 0)    # changed to proc id 8 to include zoom box. jvr
  622.         self.do_postopen()
  623.         
  624.     def do_postopen(self):
  625.         """Tell our parent we exist"""
  626.         self.parent.appendwindow(self.wid, self)
  627.         
  628.     def close(self):
  629.         self.do_postclose()
  630.             
  631.     def do_postclose(self):
  632.         self.parent.removewindow(self.wid)
  633.         self.parent = None
  634.         self.wid = None
  635.         
  636.     def SetPort(self):
  637.         # Convinience method
  638.         SetPort(self.wid)
  639.     
  640.     def do_inDrag(self, partcode, window, event):
  641.         where = event[3]
  642.         window.DragWindow(where, self.draglimit)
  643.     
  644.     draglimit = screenbounds
  645.     
  646.     def do_inGoAway(self, partcode, window, event):
  647.         where = event[3]
  648.         if window.TrackGoAway(where):
  649.             self.close()
  650.     
  651.     def do_inZoom(self, partcode, window, event):
  652.         (what, message, when, where, modifiers) = event
  653.         if window.TrackBox(where, partcode):
  654.             window.ZoomWindow(partcode, 1)
  655.             rect = window.GetWindowUserState()                # so that zoom really works... jvr
  656.             self.do_postresize(rect[2] - rect[0], rect[3] - rect[1], window)    # jvr
  657.     
  658.     def do_inZoomIn(self, partcode, window, event):
  659.         SetPort(window) # !!!
  660.         self.do_inZoom(partcode, window, event)
  661.     
  662.     def do_inZoomOut(self, partcode, window, event):
  663.         SetPort(window) # !!!
  664.         self.do_inZoom(partcode, window, event)
  665.     
  666.     def do_inGrow(self, partcode, window, event):
  667.         (what, message, when, where, modifiers) = event
  668.         result = window.GrowWindow(where, self.growlimit)
  669.         if result:
  670.             height = (result>>16) & 0xffff    # Hi word
  671.             width = result & 0xffff        # Lo word
  672.             self.do_resize(width, height, window)
  673.     
  674.     growlimit = (50, 50, screenbounds[2] - screenbounds[0], screenbounds[3] - screenbounds[1])    # jvr
  675.     
  676.     def do_resize(self, width, height, window):
  677.         l, t, r, b = self.wid.GetWindowPort().portRect            # jvr, forGrowIcon
  678.         self.SetPort()                            # jvr
  679.         InvalRect((r - SCROLLBARWIDTH + 1, b - SCROLLBARWIDTH + 1, r, b))    # jvr
  680.         window.SizeWindow(width, height, 1)        # changed updateFlag to true jvr
  681.         self.do_postresize(width, height, window)
  682.     
  683.     def do_postresize(self, width, height, window):
  684.         SetPort(window)
  685.         InvalRect(window.GetWindowPort().portRect)
  686.     
  687.     def do_inContent(self, partcode, window, event):
  688.         #
  689.         # If we're not frontmost, select ourselves and wait for
  690.         # the activate event.
  691.         #
  692.         if FrontWindow() <> window:
  693.             window.SelectWindow()
  694.             return
  695.         # We are. Handle the event.
  696.         (what, message, when, where, modifiers) = event
  697.         SetPort(window)
  698.         local = GlobalToLocal(where)
  699.         self.do_contentclick(local, modifiers, event)
  700.         
  701.     def do_contentclick(self, local, modifiers, event):
  702.         if DEBUG:
  703.             print 'Click in contents at %s, modifiers %s'%(local, modifiers)
  704.     
  705.     def do_rawupdate(self, window, event):
  706.         if DEBUG: print "raw update for", window
  707.         SetPort(window)
  708.         window.BeginUpdate()
  709.         self.do_update(window, event)
  710.         window.EndUpdate()
  711.     
  712.     def do_update(self, window, event):
  713.         if DEBUG:
  714.             import time
  715.             for i in range(8):
  716.                 time.sleep(0.1)
  717.                 InvertRgn(window.GetWindowPort().visRgn)
  718.             FillRgn(window.GetWindowPort().visRgn, qd.gray)
  719.         else:
  720.             EraseRgn(window.GetWindowPort().visRgn)
  721.         
  722.     def do_activate(self, activate, event):
  723.         if DEBUG: print 'Activate %d for %s'%(activate, self.wid)
  724.         
  725. class ControlsWindow(Window):
  726.  
  727.     def do_rawupdate(self, window, event):
  728.         if DEBUG: print "raw update for", window
  729.         SetPort(window)
  730.         window.BeginUpdate()
  731.         self.do_update(window, event)
  732.         #DrawControls(window)                    # jvr
  733.         UpdateControls(window, window.GetWindowPort().visRgn)    # jvr
  734.         window.DrawGrowIcon()
  735.         window.EndUpdate()
  736.     
  737.     def do_controlhit(self, window, control, pcode, event):
  738.         if DEBUG: print "control hit in", window, "on", control, "; pcode =", pcode
  739.  
  740.     def do_inContent(self, partcode, window, event):
  741.         if FrontWindow() <> window:
  742.             window.SelectWindow()
  743.             return
  744.         (what, message, when, where, modifiers) = event
  745.         SetPort(window)  # XXXX Needed?
  746.         local = GlobalToLocal(where)
  747.         ctltype, control = FindControl(local, window)
  748.         if ctltype and control:
  749.             pcode = control.TrackControl(local)
  750.             if pcode:
  751.                 self.do_controlhit(window, control, pcode, event)
  752.         else:
  753.             if DEBUG: print "FindControl(%s, %s) -> (%s, %s)" % \
  754.                 (local, window, ctltype, control)
  755.             self.do_contentclick(local, modifiers, event)
  756.             
  757. class ScrolledWindow(ControlsWindow):
  758.     def __init__(self, parent):
  759.         self.barx = self.bary = None
  760.         self.barx_enabled = self.bary_enabled = 1
  761.         self.activated = 1
  762.         ControlsWindow.__init__(self, parent)
  763.  
  764.     def scrollbars(self, wantx=1, wanty=1):
  765.         SetPort(self.wid)
  766.         self.barx = self.bary = None
  767.         self.barx_enabled = self.bary_enabled = 1
  768.         x0, y0, x1, y1 = self.wid.GetWindowPort().portRect
  769.         vx, vy = self.getscrollbarvalues()
  770.         if vx == None: self.barx_enabled, vx = 0, 0
  771.         if vy == None: self.bary_enabled, vy = 0, 0
  772.         if wantx:
  773.             rect = x0-1, y1-(SCROLLBARWIDTH-1), x1-(SCROLLBARWIDTH-2), y1+1
  774.             self.barx = NewControl(self.wid, rect, "", 1, vx, 0, 32767, 16, 0)
  775.             if not self.barx_enabled: self.barx.HiliteControl(255)
  776. ##            InvalRect(rect)
  777.         if wanty:
  778.             rect = x1-(SCROLLBARWIDTH-1), y0-1, x1+1, y1-(SCROLLBARWIDTH-2)
  779.             self.bary = NewControl(self.wid, rect, "", 1, vy, 0, 32767, 16, 0)
  780.             if not self.bary_enabled: self.bary.HiliteControl(255)
  781. ##            InvalRect(rect)
  782.             
  783.     def do_postclose(self):
  784.         self.barx = self.bary = None
  785.         ControlsWindow.do_postclose(self)
  786.         
  787.     def do_activate(self, onoff, event):
  788.         self.activated = onoff
  789.         if onoff:
  790.             if self.barx and self.barx_enabled:
  791.                 self.barx.ShowControl()    # jvr
  792.             if self.bary and self.bary_enabled:
  793.                 self.bary.ShowControl()    # jvr
  794.         else:
  795.             if self.barx:
  796.                 self.barx.HideControl()    # jvr; An inactive window should have *hidden*
  797.                             # scrollbars, not just dimmed (no matter what
  798.                             # BBEdit does... look at the Finder)
  799.             if self.bary:
  800.                 self.bary.HideControl()    # jvr
  801.         self.wid.DrawGrowIcon()            # jvr
  802.             
  803.     def do_postresize(self, width, height, window):
  804.         l, t, r, b = self.wid.GetWindowPort().portRect
  805.         self.SetPort()
  806.         if self.barx:
  807.             self.barx.HideControl()        # jvr
  808.             self.barx.MoveControl(l-1, b-(SCROLLBARWIDTH-1))
  809.             self.barx.SizeControl((r-l)-(SCROLLBARWIDTH-3), SCROLLBARWIDTH)    # jvr
  810.         if self.bary:
  811.             self.bary.HideControl()        # jvr
  812.             self.bary.MoveControl(r-(SCROLLBARWIDTH-1), t-1)
  813.             self.bary.SizeControl(SCROLLBARWIDTH, (b-t)-(SCROLLBARWIDTH-3))    # jvr
  814.         if self.barx:
  815.             self.barx.ShowControl()        # jvr
  816.             ValidRect((l, b - SCROLLBARWIDTH + 1, r - SCROLLBARWIDTH + 2, b))    # jvr
  817.         if self.bary:
  818.             self.bary.ShowControl()        # jvr
  819.             ValidRect((r - SCROLLBARWIDTH + 1, t, r, b - SCROLLBARWIDTH + 2))    # jvr
  820.         InvalRect((r - SCROLLBARWIDTH + 1, b - SCROLLBARWIDTH + 1, r, b))    # jvr, growicon
  821.  
  822.     def do_controlhit(self, window, control, pcode, event):
  823.         if control == self.barx:
  824.             bar = self.barx
  825.             which = 'x'
  826.         elif control == self.bary:
  827.             bar = self.bary
  828.             which = 'y'
  829.         else:
  830.             return 0
  831.         value = None
  832.         if pcode == inUpButton:
  833.             what = '-'
  834.         elif pcode == inDownButton:
  835.             what = '+'
  836.         elif pcode == inPageUp:
  837.             what = '--'
  838.         elif pcode == inPageDown:
  839.             what = '++'
  840.         else:
  841.             what = 'set'
  842.             value = bar.GetControlValue()
  843.         self.scrollbar_callback(which, what, value)
  844.         self.updatescrollbars()
  845.         return 1
  846.         
  847.     def updatescrollbars(self):
  848.         SetPort(self.wid)
  849.         vx, vy = self.getscrollbarvalues()
  850.         if self.barx:
  851.             if vx == None:
  852.                 self.barx.HiliteControl(255)
  853.                 self.barx_enabled = 0
  854.             else:
  855.                 if not self.barx_enabled:
  856.                     self.barx_enabled = 1
  857.                     if self.activated:
  858.                         self.barx.HiliteControl(0)
  859.                 self.barx.SetControlValue(vx)
  860.         if self.bary:
  861.             if vy == None:
  862.                 self.bary.HiliteControl(255)
  863.                 self.bary_enabled = 0
  864.             else:
  865.                 if not self.bary_enabled:
  866.                     self.bary_enabled = 1
  867.                     if self.activated:
  868.                         self.bary.HiliteControl(0)
  869.                 self.bary.SetControlValue(vy)
  870.             
  871.     # Auxiliary function: convert standard text/image/etc coordinate
  872.     # to something palatable as getscrollbarvalues() return
  873.     def scalebarvalue(self, absmin, absmax, curmin, curmax):
  874.         if curmin <= absmin and curmax >= absmax:
  875.             return None
  876.         if curmin <= absmin:
  877.             return 0
  878.         if curmax >= absmax:
  879.             return 32767
  880.         perc = float(curmin-absmin)/float(absmax-absmin)
  881.         return int(perc*32767)
  882.             
  883.     # To be overridden:
  884.     
  885.     def getscrollbarvalues(self):
  886.         return 0, 0
  887.         
  888.     def scrollbar_callback(self, which, what, value):
  889.         print 'scroll', which, what, value
  890.     
  891. class DialogWindow(Window):
  892.     """A modeless dialog window"""
  893.     
  894.     def open(self, resid):
  895.         self.wid = GetNewDialog(resid, -1)
  896.         self.do_postopen()
  897.         
  898.     def close(self):
  899.         self.do_postclose()
  900.         
  901.     def do_itemhit(self, item, event):
  902.         print 'Dialog %s, item %d hit'%(self.wid, item)
  903.         
  904.     def do_rawupdate(self, window, event):
  905.         pass
  906.  
  907. def ostypecode(x):
  908.     "Convert a long int to the 4-character code it really is"
  909.     s = ''
  910.     for i in range(4):
  911.         x, c = divmod(x, 256)
  912.         s = chr(c) + s
  913.     return s
  914.  
  915.  
  916. class TestApp(Application):
  917.     
  918.     "This class is used by the test() function"
  919.     
  920.     def makeusermenus(self):
  921.         self.filemenu = m = Menu(self.menubar, "File")
  922.         self.saveitem = MenuItem(m, "Save", "S", self.save)
  923.         Separator(m)
  924.         self.optionsmenu = mm = SubMenu(m, "Options")
  925.         self.opt1 = CheckItem(mm, "Arguments")
  926.         self.opt2 = CheckItem(mm, "Being hit on the head lessons")
  927.         self.opt3 = CheckItem(mm, "Complaints")
  928.         Separator(m)
  929.         self.quititem = MenuItem(m, "Quit", "Q", self.quit)
  930.     
  931.     def save(self, *args):
  932.         print "Save"
  933.     
  934.     def quit(self, *args):
  935.         raise self
  936.  
  937.  
  938. def test():
  939.     "Test program"
  940.     app = TestApp()
  941.     app.mainloop()
  942.  
  943.  
  944. if __name__ == '__main__':
  945.     test()
  946.